package com.clf.data.redis.core.json.ops.impl;

import com.clf.data.redis.core.json.FastJsonRedisTemplate;
import com.clf.data.redis.core.json.ops.FastJsonBoundZSetOperations;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.connection.RedisZSetCommands.Limit;
import org.springframework.data.redis.connection.RedisZSetCommands.Range;
import org.springframework.data.redis.core.BoundZSetOperations;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;

import java.util.Collection;
import java.util.Date;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * ops覆盖类，可提供原先ops没有的方法
 *
 * @param <K>
 * @param <V>
 * @author <a href="mailto:zhudelie@zuozh.com">zhudelie</a>
 * @since JDK 1.6
 */
public class FastJsonBoundZSetOperationsImpl<K, V> extends OperationsAware<K, V> implements FastJsonBoundZSetOperations<K, V> {
    private BoundZSetOperations<K, V> ops;

    public FastJsonBoundZSetOperationsImpl(BoundZSetOperations<K, V> ops, FastJsonRedisTemplate<K, V> template) {
        super(template);
        this.ops = ops;
    }

    public BoundZSetOperations<K, V> getOps() {
        return ops;
    }

    /**
     * 获得key
     */
    @Override
    public K getKey() {
        // TODO Auto-generated method stub
        return (K) getOps().getKey();
    }

    /**
     * 获得类型
     */
    @Override
    public DataType getType() {
        // TODO Auto-generated method stub
        return getOps().getType();
    }

    @Override
    public Long getExpire() {
        // TODO Auto-generated method stub
        return getOps().getExpire();
    }

    /**
     * 设置过期时间
     */
    @Override
    public Boolean expire(long timeout, TimeUnit unit) {
        // TODO Auto-generated method stub
        return getOps().expire(timeout, unit);
    }

    /**
     * 设置过期时间
     */
    @Override
    public Boolean expireAt(Date date) {
        // TODO Auto-generated method stub
        return getOps().expireAt(date);
    }

    /**
     * 取消过期时间
     */
    @Override
    public Boolean persist() {
        // TODO Auto-generated method stub
        return getOps().persist();
    }

    /**
     * 重命名
     */
    @Override
    public void rename(K newKey) {
        getOps().rename(newKey);
    }


    /**
     * 添加值
     */
    @Override
    public Boolean add(V value, double score) {
        // TODO Auto-generated method stub
        return getOps().add(value, score);
    }

    /**
     * 添加多个值
     */
    @Override
    public Long add(Set<TypedTuple<V>> tuples) {
        // TODO Auto-generated method stub
        return getOps().add(tuples);
    }

    /**
     * 删除多个值
     */
    @Override
    public Long remove(Object... values) {
        // TODO Auto-generated method stub
        return getOps().remove(values);
    }

    /**
     * 添加单位成员的有序集合存储增量键比分
     */
    @Override
    public Double incrementScore(V value, double delta) {
        // TODO Auto-generated method stub
        return getOps().incrementScore(value, delta);
    }

    /**
     * 返回成员的有序集合保存在key，由低到高的分数顺序排名
     */
    @Override
    public Long rank(Object o) {
        // TODO Auto-generated method stub
        return getOps().rank(o);
    }

    /**
     * 返回有序集中成员的排名。其中有序集成员按分数值递减(从大到小)排序
     */
    @Override
    public Long reverseRank(Object o) {
        // TODO Auto-generated method stub
        return getOps().reverseRank(o);
    }

    /**
     * 取有序集中第start位到end位的元素
     */
    @Override
    public Set<V> range(long start, long end) {
        // TODO Auto-generated method stub
        return getOps().range(start, end);
    }

    /**
     * 取有序集中第start位到end位的元素，返回TypedTuple，包含score
     */
    @Override
    public Set<TypedTuple<V>> rangeWithScores(long start, long end) {
        // TODO Auto-generated method stub
        return getOps().rangeWithScores(start, end);
    }

    /**
     * 取有序集中分数为min到max的元素
     */
    @Override
    public Set<V> rangeByScore(double min, double max) {
        // TODO Auto-generated method stub
        return getOps().rangeByScore(min, max);
    }

    /**
     * 取有序集中分数为min到max的元素，返回TypedTuple，包含score
     */
    @Override
    public Set<TypedTuple<V>> rangeByScoreWithScores(double min, double max) {
        // TODO Auto-generated method stub
        return getOps().rangeByScoreWithScores(min, max);
    }

    /**
     * 对start到end的元素进行倒序
     */
    @Override
    public Set<V> reverseRange(long start, long end) {
        // TODO Auto-generated method stub
        return getOps().reverseRange(start, end);
    }

    /**
     * 对start到end的元素进行倒序，并返回TypedTuple，包含score
     */
    @Override
    public Set<TypedTuple<V>> reverseRangeWithScores(long start, long end) {
        // TODO Auto-generated method stub
        return getOps().reverseRangeWithScores(start, end);
    }

    /**
     * 对分数为min到max的元素进行倒序
     */
    @Override
    public Set<V> reverseRangeByScore(double min, double max) {
        // TODO Auto-generated method stub
        return getOps().reverseRangeByScore(min, max);
    }

    /**
     * 对分数为min到max的元素进行倒序，并返回TypedTuple，包含score
     */
    @Override
    public Set<TypedTuple<V>> reverseRangeByScoreWithScores(double min, double max) {
        // TODO Auto-generated method stub
        return getOps().reverseRangeByScoreWithScores(min, max);
    }

    /**
     * 统计分数值在min到max范围内的元素个数
     */
    @Override
    public Long count(double min, double max) {
        // TODO Auto-generated method stub
        return getOps().count(min, max);
    }

    /**
     * 元素个数
     */
    @Override
    public Long size() {
        // TODO Auto-generated method stub
        return getOps().size();
    }

    @Override
    public Long zCard() {
        // TODO Auto-generated method stub
        return getOps().zCard();
    }

    /**
     * 指定元素的分数
     */
    @Override
    public Double score(Object o) {
        // TODO Auto-generated method stub
        return getOps().score(o);
    }

    /**
     * 删除下标start到end的元素
     */
    @Override
    public void removeRange(long start, long end) {
        getOps().removeRange(start, end);
    }

    /**
     * 删除分数min到max的元素
     */
    @Override
    public void removeRangeByScore(double min, double max) {
        getOps().removeRangeByScore(min, max);
    }

    /**
     * 并集，如果destkey存在，则覆盖
     */
    @Override
    public void unionAndStore(K otherKey, K destKey) {
        getOps().unionAndStore(otherKey, destKey);
    }

    /**
     * 并集，如果destkey存在，则覆盖
     */
    @Override
    public void unionAndStore(Collection<K> otherKeys, K destKey) {
        getOps().unionAndStore(otherKeys, destKey);
    }

    /**
     * 交集，如果destkey存在，则覆盖
     */
    @Override
    public void intersectAndStore(K otherKey, K destKey) {
        getOps().intersectAndStore(otherKey, destKey);
    }

    /**
     * 交集，如果destkey存在，则覆盖
     */
    @Override
    public void intersectAndStore(Collection<K> otherKeys, K destKey) {
        getOps().intersectAndStore(otherKeys, destKey);
    }

    @Override
    public Cursor<TypedTuple<V>> scan(ScanOptions options) {
        // TODO Auto-generated method stub
        return getOps().scan(options);
    }

    /**
     * 返回存储在键的排序集合在指定的范围元素。该元素被认为是从最低到最高的分值进行排序。字典顺序用于以相等的分数的元素。两个开始和结束是从零开始的索引，其中0是第一个元素，1是下一个元素等等。它们也可以是表示偏移量从有序集的结尾，以-1作为排序的集合的最后一个元素，-2倒数第二元素等负数
     */
    @Override
    public Set<V> rangeByLex(Range range) {
        // TODO Auto-generated method stub
        return getOps().rangeByLex(range);
    }

    /**
     * 返回存储在键的排序集合在指定的范围元素。该元素被认为是从最低到最高的分值进行排序。字典顺序用于以相等的分数的元素。两个开始和结束是从零开始的索引，其中0是第一个元素，1是下一个元素等等。它们也可以是表示偏移量从有序集的结尾，以-1作为排序的集合的最后一个元素，-2倒数第二元素等负数
     */
    @Override
    public Set<V> rangeByLex(Range range, Limit limit) {
        // TODO Auto-generated method stub
        return getOps().rangeByLex(range, limit);
    }


}
